/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.dubbo.config.spring.context.annotation;

import org.apache.dubbo.config.spring.beans.factory.annotation.ServiceAnnotationBeanPostProcessor;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.ClassUtils;

import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;

import static org.apache.dubbo.config.spring.util.DubboBeanUtils.registerCommonBeans;
import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;

/**
 * Dubbo {@link DubboComponentScan} Bean Registrar
 *
 * @see Service
 * @see DubboComponentScan
 * @see ImportBeanDefinitionRegistrar
 * @see ServiceAnnotationBeanPostProcessor
 * @see ReferenceAnnotationBeanPostProcessor
 * @since 2.5.7
 */

/**
 * 这个bean也是dubbo通过spring的特性@Import引入的，这个bean很显然就是去处理dubbo的@Service注解的
 * 首先要明白的是我们使用dubbo在service上加了@Service注解，那么这是dubbo的注解，不是spring的@Service注解
 * 但是最终肯定也要作为spring的一个bean放入容器中的，所以我们可以这样理解就是在service层使用dubbo的@Service注解
 * dubbo要做的事情就是将这个service作为一个bean放入spring容器，同样的，这个service还是一个dubbo 服务
 * 作为一个dubbo服务需要注册到注册中心，比如zookeeper中的，所以引入的这个bean要做的两件事儿是：
 * 1.扫描到@Service，创建一个新的BeanDefinition放入spring容器；
 * 2.创建dubbo服务ServiceBean(dubbo)也注册到spring容器中，并且在spring启动完成过后通过事件监听的机制
 * 通知dubbo开始向注册中心进行服务的注册。
 * 我们都知道dubbo的@Service包含了很多信息，比如protocol，timeout，version，group等等信息，所以一般的一个
 * bean是不能满足的，所以dubbo在这里处理自己的ServiceBean的时候，将这些信息都保存到ServiceBea中
 * 然后注册到spring容器，当spring容器启动好了过后，进行服务的注册，那么就可以从spring容器中取出这些bean
 * 进行服务的注册，需要注意的是ServiceBean是一个泛型的类，比如dubbo中有10个@Service，那么会向spring
 * 容器中注册10个ServicceBean，但是bean的名字是不一样的，也就是在spring容器中有10个ServiceBean
 * 每个servicebean都包含了自己的注册信息，比如版本、注册中心地址、应用名称等。
 * <p>
 * 3.处理@Reference注解，第二点说的处理@Service是作为服务提供方进行处理的，而@Referenc是作为
 * 服务消费者进行处理的，简单来说和spring的@AutoWired很类似，是在bean的后置处理器中进行处理的
 *
 * @Reference中所包含了属性和@Service中基本一致，一个是服务提供方，一个是服务消费方，
 * @Reference是需要产生一个代理对象的，当我们远程调用的时候进入的就是@Reference生成的代理对象 然后进行远程调用。
 * <p>
 * 4.注册监听器，当spring启动或者停止的时候出发一些事件，比如spring容器启动完成了需要进行服务注册
 */
public class DubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        /**
         * 这里是得到@EnableDubbo上配置的扫描路径，因为dubbo扫描符合条件的@Service也是
         * 需要根据指定的路径去扫描的，和spring的机制一样的，配置的路径可以有多个
         * 也可以配置一个，所以这里是一个set集合
         */
        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);

        //处理dubbo的@Service注解
        registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);

        // @since 2.7.6 Register the common beans
        //向spring容器注册消费端的bean后置处理器和监听器的bean，消费端的bean后置处理器这里主要说的是@Reference这个注解
        /**
         * 这里有一个小的知识点就是registerCommonBeans是一个接口中的方法，这里可以直接通过import一个static的方法
         * 这里就可以直接调用
         * 比如import static org.apache.dubbo.config.spring.util.DubboBeanUtils.registerCommonBeans;
         * 这个类就可以直接使用DubboBeanUtils中的方法registerCommonBeans
         */
        registerCommonBeans(registry);
    }

    /**
     * Registers {@link ServiceAnnotationBeanPostProcessor}
     *
     * @param packagesToScan packages to scan without resolving placeholders
     * @param registry       {@link BeanDefinitionRegistry}
     * @since 2.5.8
     * 这个方法做的事情就是
     * 1.将dubbo的@Service找到，生成一个BeanDefinition放入spring容器；
     * 2.再创建一个ServiceBean<T>，将@Service中的属性设置到ServiceBean对象中，
     * 然后再生成一个beanName放入spring容器
     */
    private void registerServiceAnnotationBeanPostProcessor(Set<String> packagesToScan, BeanDefinitionRegistry registry) {

        //其实这里没做其他太多事情，是向spring容器注册了一个bean工厂的后置处理器，所以这个名字取的不好
        //ServiceAnnotationBeanPostProcessor从名字看是Bean的后置处理器，其实它是bean工厂的后置处理器
        BeanDefinitionBuilder builder = rootBeanDefinition(ServiceAnnotationBeanPostProcessor.class);
        //这里是将扫描路径packagesToScan通过构造方法注入进去，当spring在推断构造方法的时候就会得到
        //这个构造方法，然后将这里设置的扫描路径给注册进去，其实就是一个简单的扫描路径赋值
        builder.addConstructorArgValue(packagesToScan);
        builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);

    }

    private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                metadata.getAnnotationAttributes(DubboComponentScan.class.getName()));
        String[] basePackages = attributes.getStringArray("basePackages");
        Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
        String[] value = attributes.getStringArray("value");
        // Appends value array attributes
        Set<String> packagesToScan = new LinkedHashSet<String>(Arrays.asList(value));
        packagesToScan.addAll(Arrays.asList(basePackages));
        for (Class<?> basePackageClass : basePackageClasses) {
            packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
        }
        if (packagesToScan.isEmpty()) {
            return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName()));
        }
        return packagesToScan;
    }

}
